/**
 * 门店数据管理模块
 * 提供门店数据的全局缓存和管理功能
 */

const apiService = require('./api.js');

class StoreManager {
  constructor() {
    this.storeList = []; // 门店列表缓存
    this.storeMap = new Map(); // 门店ID映射，便于快速查找
    this.isLoaded = false; // 是否已加载数据
    this.isLoading = false; // 是否正在加载
    this.loadPromise = null; // 加载Promise，避免重复请求
    this.cacheTime = 0; // 缓存时间戳
    this.cacheExpiry = 30 * 60 * 1000; // 缓存过期时间：30分钟
  }

  /**
   * 初始化门店数据
   * @param {boolean} forceRefresh 是否强制刷新
   * @returns {Promise<Array>} 门店列表
   */
  async init(forceRefresh = false) {
    // 如果正在加载，返回加载Promise
    if (this.isLoading && this.loadPromise) {
      return this.loadPromise;
    }

    // 检查缓存是否有效
    if (!forceRefresh && this.isLoaded && this.isCacheValid()) {
      return this.storeList;
    }

    // 开始加载数据
    this.isLoading = true;
    this.loadPromise = this.loadStoreData();

    try {
      const result = await this.loadPromise;
      return result;
    } finally {
      this.isLoading = false;
      this.loadPromise = null;
    }
  }

  /**
   * 加载门店数据
   * @returns {Promise<Array>} 门店列表
   */
  async loadStoreData() {
    try {
      console.log('StoreManager: 开始加载门店数据...');
      
      // 使用门店附近的默认位置，确保能获取到门店数据
      // 注意：如果使用用户实际位置，可能因距离太远而获取不到门店
      const userLocation = { longitude: 119.3649, latitude: 26.0745 };
      console.log('StoreManager: 使用默认位置（门店附近）:', userLocation);
      
      // 可选：获取用户实际位置用于距离计算，但不用于API查询
      // try {
      //   const actualLocation = await this.getUserLocation();
      //   console.log('StoreManager: 用户实际位置:', actualLocation);
      // } catch (error) {
      //   console.log('StoreManager: 获取用户位置失败');
      // }

      // 调用API获取门店列表
      const result = await apiService.getStoreList(
        userLocation.longitude, 
        userLocation.latitude, 
        50 // 50公里范围
      );

      if (result.success && result.data) {
        this.updateCache(result.data);
        console.log(`StoreManager: 门店数据加载成功，共${this.storeList.length}个门店`);
        return this.storeList;
      } else {
        throw new Error(result.message || '获取门店列表失败');
      }
    } catch (error) {
      console.error('StoreManager: 加载门店数据失败:', error);
      
      // 如果有缓存数据，返回缓存
      if (this.storeList.length > 0) {
        console.log('StoreManager: 使用缓存数据');
        return this.storeList;
      }
      
      // 返回默认门店数据
      return this.getDefaultStoreData();
    }
  }

  /**
   * 更新缓存数据
   * @param {Array} storeList 门店列表
   */
  updateCache(storeList) {
    this.storeList = storeList || [];
    this.storeMap.clear();
    
    // 建立ID映射
    this.storeList.forEach(store => {
      // 支持多种ID格式
      if (store._id) this.storeMap.set(store._id, store);
      if (store.storeId) this.storeMap.set(store.storeId.toString(), store);
      if (store.id) this.storeMap.set(store.id.toString(), store);
    });
    
    this.isLoaded = true;
    this.cacheTime = Date.now();
  }

  /**
   * 检查缓存是否有效
   * @returns {boolean} 缓存是否有效
   */
  isCacheValid() {
    return Date.now() - this.cacheTime < this.cacheExpiry;
  }

  /**
   * 获取门店列表
   * @param {boolean} forceRefresh 是否强制刷新
   * @returns {Promise<Array>} 门店列表
   */
  async getStoreList(forceRefresh = false) {
    return await this.init(forceRefresh);
  }

  /**
   * 根据ID获取门店详情
   * @param {string|number} storeId 门店ID
   * @returns {Promise<Object|null>} 门店详情
   */
  async getStoreById(storeId) {
    // 确保数据已加载
    await this.init();
    
    // 从缓存中查找
    const store = this.storeMap.get(storeId.toString());
    if (store) {
      return store;
    }
    
    // 缓存中没有，尝试从API获取
    try {
      const result = await apiService.getStoreDetail(storeId);
      if (result.success && result.data) {
        return result.data.storeInfo || result.data;
      }
    } catch (error) {
      console.error('StoreManager: 获取门店详情失败:', error);
    }
    
    return null;
  }

  /**
   * 获取最近的门店
   * @param {Object} userLocation 用户位置 {longitude, latitude}
   * @returns {Promise<Object|null>} 最近的门店
   */
  async getNearestStore(userLocation = null) {
    await this.init();
    
    if (this.storeList.length === 0) {
      return null;
    }
    
    // 如果没有用户位置，返回第一个门店或storeId为'store_001'的门店
    if (!userLocation) {
      const defaultStore = this.storeList.find(store => store.storeId === 'store_001') || this.storeList[0];
      return defaultStore;
    }
    
    // 计算距离并返回最近的门店
    let nearestStore = null;
    let minDistance = Infinity;
    
    this.storeList.forEach(store => {
      if (store.location && store.location.longitude && store.location.latitude) {
        const distance = this.calculateDistance(
          userLocation.latitude, userLocation.longitude,
          store.location.latitude, store.location.longitude
        );
        
        if (distance < minDistance) {
          minDistance = distance;
          nearestStore = store;
        }
      }
    });
    
    return nearestStore || this.storeList[0];
  }

  /**
   * 刷新门店数据
   * @returns {Promise<Array>} 门店列表
   */
  async refresh() {
    console.log('StoreManager: 手动刷新门店数据');
    return await this.init(true);
  }

  /**
   * 检查并自动刷新过期缓存
   * @returns {Promise<Array>} 门店列表
   */
  async checkAndRefresh() {
    if (!this.isCacheValid()) {
      console.log('StoreManager: 缓存已过期，自动刷新');
      return await this.refresh();
    }
    return this.storeList;
  }

  /**
   * 获取缓存状态信息
   * @returns {Object} 缓存状态
   */
  getCacheStatus() {
    return {
      isLoaded: this.isLoaded,
      isLoading: this.isLoading,
      cacheTime: this.cacheTime,
      cacheValid: this.isCacheValid(),
      storeCount: this.storeList.length,
      cacheAge: Date.now() - this.cacheTime
    };
  }

  /**
   * 清除缓存
   */
  clearCache() {
    console.log('StoreManager: 清除缓存数据');
    this.storeList = [];
    this.storeMap.clear();
    this.isLoaded = false;
    this.cacheTime = 0;
    this.isLoading = false;
    this.loadPromise = null;
  }

  /**
   * 重置管理器状态
   */
  reset() {
    console.log('StoreManager: 重置管理器状态');
    this.clearCache();
  }

  /**
   * 获取用户位置
   * @returns {Promise<Object>} 位置信息
   */
  getUserLocation() {
    return new Promise((resolve, reject) => {
      wx.getLocation({
        type: 'gcj02',
        success: (res) => {
          resolve({
            longitude: res.longitude,
            latitude: res.latitude
          });
        },
        fail: (error) => {
          reject(error);
        }
      });
    });
  }

  /**
   * 计算两点间距离（公里）
   * @param {number} lat1 纬度1
   * @param {number} lon1 经度1
   * @param {number} lat2 纬度2
   * @param {number} lon2 经度2
   * @returns {number} 距离（公里）
   */
  calculateDistance(lat1, lon1, lat2, lon2) {
    const R = 6371; // 地球半径（公里）
    const dLat = this.deg2rad(lat2 - lat1);
    const dLon = this.deg2rad(lon2 - lon1);
    const a = 
      Math.sin(dLat / 2) * Math.sin(dLat / 2) +
      Math.cos(this.deg2rad(lat1)) * Math.cos(this.deg2rad(lat2)) * 
      Math.sin(dLon / 2) * Math.sin(dLon / 2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    return R * c;
  }

  /**
   * 角度转弧度
   * @param {number} deg 角度
   * @returns {number} 弧度
   */
  deg2rad(deg) {
    return deg * (Math.PI / 180);
  }

  /**
   * 获取默认门店数据（降级处理）
   * @returns {Array} 默认门店列表
   */
  getDefaultStoreData() {
    const defaultStore = {
      _id: 'store_001',
      storeId: 'store_001',
      name: '超级泡泡-24小时自助宠物(蓝光店)',
      address: '福建省福州市晋安区鼓山镇前横北路蓝光星珀9#19',
      location: {
        longitude: 119.3649,
        latitude: 26.0745
      },
      phone: '18558880680',
      openingHours: '09:00-22:00',
      status: 1
    };
    
    this.updateCache([defaultStore]);
    console.log('StoreManager: 使用默认门店数据');
    return this.storeList;
  }
}

// 创建全局单例
const storeManager = new StoreManager();

module.exports = storeManager;